export default class ApprovalNode {
  constructor (list, proId) {
    this.list = list
    this.proId = proId
  }

  getNodes () {
    let parentNode = 0 // 对循环内的当前节点来说，它的父节点是哪个
    let mainNodeCount = 0 // 主节点计数
    let childNodeCount = 0 // 子节点计数

    const flowNode = this.list.flatMap((v, i) => {
      const res = []

      if (v.isMain) {
        mainNodeCount++
        childNodeCount = 0
      } else {
        const lastNode = this.list[i - 1]
        // 条件节点
        if (lastNode) {
          if (lastNode.isMain) {
            mainNodeCount++
            const cNodeId = `3${String(mainNodeCount).padStart(2, 0)}${String(childNodeCount).padStart(3, 0)}0`
            parentNode = cNodeId
            res.push({
              nodeType: 2,
              actionType: 2,
              phaseType: 1,
              showInProcess: 1,
              nextSiblingCode: null,
              prevSiblingCode: null,
              code: cNodeId,
              proId: this.proId
            })
          }
        } else {
          // 第一个就是条件分支
          mainNodeCount++
          parentNode = '3010000'
          res.push({
            nodeType: 2,
            actionType: 2,
            phaseType: 1,
            showInProcess: 1,
            nextSiblingCode: null,
            prevSiblingCode: null,
            code: '3010000',
            proId: this.proId
          })
        }
        childNodeCount++
      }

      const nodeId = `3${String(mainNodeCount).padStart(2, 0)}${String(childNodeCount).padStart(3, 0)}0`
      if (v.isMain) {
        parentNode = nodeId
      }
      res.push({
        /**
         * 节点类型：2 条件判断节点，3 需人参与的节点
         */
        nodeType: 3,
        /**
         * 节点要执行的动作标识：2 判断是否需要特批科目费用， 4 审批
         */
        actionType: 4,
        /**
         * 节点在流程中所在的处理阶段：1 审核阶段
         */
        phaseType: 1,
        /**
         * 节点是否在前端的处理记录中显示：0不显示，1显示
         */
        showInProcess: 1,
        /**
         * 父节点编号：主节点的父节点编号为null，分支节点的父节点编号有值
         */
        parentCode: v.isMain ? null : parentNode,
        /**
         * 节点编号
         */
        code: nodeId,
        /**
         * 下一个处理节点的编号
         */
        nextSiblingCode: null,
        /**
         * 前一个处理节点的编号，预留暂不用
         */
        prevSiblingCode: null,
        /**
         * 1到账号 2到角色
         */
        type: v.ids.length ? 1 : 2,
        /**
         * 处理人id：逗号分隔，type=1时有效
         */
        processorId: v.ids.toString(),
        roleId: v.roleId,
        roleName: v.roleName,
        roleCode: v.roleCode,
        proId: this.proId,
        /**
         * 费用科目类型（特批分支使用）
         */
        applyType: v.applyType || null
      })
      return res
    })

    // 只有主节点有prevSiblingCode和nextSiblingCode
    const flowMainNode = flowNode.filter(v => !v.parentCode)
    flowMainNode.forEach((v, i) => {
      if (i > 0) {
        v.prevSiblingCode = flowMainNode[i - 1].code
      }
      if (i < flowMainNode.length - 1) {
        v.nextSiblingCode = flowMainNode[i + 1].code
      }
    })

    return flowNode
  }
}
